Power Programmierung

home *** CD-ROM | disk | FTP | other *** search

/ Power Programmierung / Power-Programmierung (Tewi)(1994).iso / qtawk / qtawk.man < prev next >

Wrap

Text File | 1990-11-04 | 38KB | 887 lines

QTAwk Version 4.20 10/10/90 QTAwk Name QTAwk - Pattern Scanning and Processing Language QTAwk - Version 4.20 10/10/90 Synopsis qtawk [-f file | -ffile | "program"] [-Fstr] [var=text | file | - | -- ] ... DESCRIPTION QTAwk scans each input file for lines that match any of a set of patterns specified in the program. With each pattern in the program there can be an associated action that will be performed when a line of a file matches the pattern. The QTAwk program may be specified as a file with the -f option as: -ffilename.ext -f filename.ext in which case the QTAwk program is read from the named file. If the file does not exist then an error message will be printed. Multiple 'f' options specifying program files may be used. Each program file is read in the order given and the total program consists of all files read. The QTAwk program may also be specified as a single argument as: "{ for (i in ARGV) printf ("%d: %s\n", i, ARGV[i]); }" If the -f option is selected the full path/name/extension must be specified. Files are read in order, the file name '-' means standard input. Each line is matched against the pattern portion of every pattern/action statement. The associated action is performed for each matched pattern. A command line argument of "--" will stop the scan for more options. If a file name has the form variable=value or "variable = value", the variable named is set to the value specified. Program variables may be changed before a file is read. The assignment takes place when the argument would be treated as the next file to read. "variable" must be a variable name defined in the QTAwk program. qtawk "{ print code, NR, $0 }" code=10 file1 code=75 file2 No assignment will happen before a BEGIN block, however an assignment after the last file will occur before any END block unless an exit was performed. If no files are specified the input is read from standard input. An input line is made up of fields separated by the field separator FS. The fields are denoted by $1, $2, ..., $NF. NF equals the number of fields the input record has been split to make. $0 denotes the entire line: $0 = "now is the time" $1 = "now" $2 = "is" $3 = "the" $4 = "time" with the default FS = {_w}, white space. If the field separator is set to comma, ',' with "-F," on the command line or "FS=','" on the command line, or in the program, then the fields might be: $0 = "a, b,c,, ," $1 = "a" $2 = " b" $3 = "c" $4 = "" $5 = " " $6 = "" A pattern-action statement has the form: pattern { action } A missing { action } has the same effect as { print $0; }, a missing pattern always matches. A pattern is a test that is performed on each input line. If the pattern matches the input line then the corresponding action is performed. Patterns come in several forms: Form Example Meaning BEGIN BEGIN {N=1;} initialize N before input is read INITIAL INITIAL {G=0;) initialize G before input from each file NOMATCH NOMATCH (G++;} increment G for each line not matched FINAL FINAL {print G;} print G after each file END END {print NR} print NR after all input is read function function x(y) define a function called x text match /stop/ line contains the string "stop" expression $1 == 3 first field is the number 3 compound /x/ && NF > 2 more that two fields and contain "x" range FNR==10,FNR==20 records ten through twenty inclusive BEGIN, INITIAL, NOMATCH, FINAL and END patterns are special patterns that match respectively: before any files are opened, after opening each file, when a line fails all patterns, after reading the last line in each file and after all files have been closed. There may be multiple occurances of these patterns and the associated actions are executed in the order that they occur. If there is only a series of BEGIN blocks in the QTAwk program and no other pattern/action blocks except function declarations, they are executed before reading from the standard input. If only END blocks are defined then all the files are read and NR will be set to the number of records in all the files. BEGIN { page = 5 } A function pattern is never matched and serves to declare a user defined function. function show(a) {local i; for (i in a) print a[i];} A user defined function may have a variable number of arguments defined following the C convention: function max(...) { local i, maxa = vargv[1]; for ( i in vargv ) if ( vargv[i] > maxa ) maxa = vargv[i]; return maxa; } The variable arguments are accessed through the built-in variables vargc == the number of variable arguments passed, and vargv == an array with element indices 1 through vargc, each element is an argument passed. A regular expression by itself is matched against the input record, $0. That is "/abc/" is equivalent to "$0 ~~ /abc/". Any expression will match if it evaluates to a non-zero numeric or a non-null string. Also any logical combination of expressions and regular expressions may be used as a pattern. FILENAME != oldname && FILENAME != "skip" The last special pattern is two expressions separated by a comma. This pattern specifies a range of records that match the pattern. The pattern starts to match when the first pattern matches and stops matching when the second pattern matches. If they both match on the same input record then only that record will match the pattern. /AUTHOR/,/NOTES/ An action is a sequence of statements that are performed when a pattern matches. A statement can be one of the following: # simple statement STATEMENT # compound statement { STATEMENT; STATEMENT; STATEMENT; STATEMENT; ... } # simple expression EXPRESSION # expression list - expressions separated by the sequence operator EXPRESSION, EXPRESSION, EXPRESSION, ... print EXPRESSION_LIST; print( EXPRESSION_LIST ); printf FORMAT ; printf FORMAT ,EXPRESSION_LIST ; printf(FORMAT ); printf(FORMAT ,EXPRESSION_LIST ); fprint(filename,EXPRESSION_LIST); fprintf(filename,FORMAT ); fprintf(filename,FORMAT ,EXPRESSION_LIST ); getline( ); getline( variable ); fgetline(filename); fgetline(filename ,variable ); if ( EXPRESSION_LIST ) STATEMENT if ( EXPRESSION_LIST ) STATEMENT else STATEMENT for ( VARIABLE in ARRAY ) STATEMENT for ( EXPRESSION_1 ; EXPRESSION_2 ; EXPRESSION_3 ) STATEMENT while ( EXPRESSION ) STATEMENT do STATEMENT while ( EXPRESSION ); switch ( EXPRESSION ) { case EXPRESSION_1: STATEMENT case EXPRESSION_2: STATEMENT default: STATEMENT } break; continue; cycle; delete variable[i]; deletea variable; endfile; exit ; exit EXPRESSION_LIST ; local variable_list; local variable_list = value; next; return ; return EXPRESSION ; A Compound Statement is a list of statements separated by semicolons and enclosed within braces, "{}". White space is ignored beyond delimiting tokens. Thus, statements may be split across lines where, or as necessary, for readability: { print "value:", i, "number:", j; i = i + $3; j++; } An EXPRESSION_LIST is any number of valid expressions separated by the sequence operator, the comma ','. Expressions take on string or numeric values depending on the operators. There is only one string operator, concatenation, indicated by adjacent expressions or the symbol ∩ (extended ASCII hexadecimal 0xef, decimal 239). The following are the operators in order of increasing precedence: Operation Operator Example Meaning sequence , x=2,y=3; assign 3 to y then assign 2 to x assignment = x = 2 two is assigned to x assignment ^= *= /= x += 2 two is added to x %= += -= &= |= @= <<= >>= ∩= conditional ? : x ? y : z if x then y else z logical OR || x || y if (x) 1, else if (y) 1, else 0 logical AND && x && y if (x) if (y) 1, else 0, else 0 bit-wise XOR @ x @ y x XOR y bit-wise OR | x | y x OR y bit-wise AND & x & y x AND y array membership in x in y if ( exists(y[x]) ) 1 else 0 matching ~~ !~ $1 ~~ /x/ if ($1 contains x) 1 else 0 equality == != x == y if (x equals y) 1 else 0 relational < <= >= > x < y if (x less than y) 1 else 0 <= >= < bit shift << >> x << 2 shift value of x 2 bits left concatenation "x" "y" a new string "xy" concatenation ∩ "x" ∩ "y" a new string "xy" add, subtract + - x + y sum of x and y mul, div, mod * / % x * y product of x and y exponentiation ^ x^y x to the yth power unary plus minus + - -x negative of x inc/dec ++ -- x++ x then add 1 to x logical not ! !x if (x is 0 or null) 1 else 0 tag $$ $$0 the string matched in the pattern field $ $3 the 3rd field subscripting [] x[2] element 2 of x grouping () ($1)++ increment the 1st field Variables may be scalars, array elements (denoted x[i]) or fields (denoted $expression). Variable names begin with a letter or underscore and may contain any number of letters, digits, or underscores. Array subscripts may be any integer or string. Multi-dimensional arrays are supported by QTAwk and accessed in the C manner: x[2][1] Variables are initialized to both zero and the null string. Fields and the command line arguments will be both string and numeric if they can be completely represented as numbers. The range for numbers is 1E-306 ... 1E306. for numeric operations, if both operands are integers, the result is an integer. Thus, 3 / 2 is 1, but 3.0 / 2 is 1.5. Comparison will be numeric if both operands are numeric otherwise a string comparison will be made. Operands will be coerced to strings if necessary. Uninitialized variables will compare as numeric if the other operand is numeric or uninitialized. Eg. 2 > "10" and 2 < 10. There are a number of built in variables they are: Variable Meaning Default _arg_chk flag to check number of arguments 0 ARGC number of command line arguments - ARGI array of command line arguments - ARGV subscript value for next command line argument - CYCLE_COUNT Count of cycle statement - DEGREES degree flag 0 ENVIRON array of environment strings - FALSE false 0 FILENAME name of current input file - FNR record number in current file - FS controls the input field separator /{_z}+/ LONGEST_EXP Longest Expression 1 MAX_CYCLE Max count of cycle statement 100 NF number of fields in current record - NG expression count - NR number of records read so far - OFMT output format for records "%.6g" OFS output field separator " " ORS output record separator "\n" RETAIN_FS Flag to retain Field Separator 0 RS controls input record separator "\n" TRACE Flag to Trace Statements 0 TRANS_FROM String Translation "ABCDEFGHIJKLMNOPQRSTUVWXYZ" TRANS_TO String Translation "abcdefghijklmnopqrstuvwxyz" TRUE true 1 CLENGTH length of string matched in case statement - CSTART start of string match in case statement - MLENGTH length of string matched in pattern match - MSTART start of string match in pattern match - RLENGTH length of string matched by match function - RSTART start of string match by match function - vargc Variable Argument count - vargv Variable Argument array - ARGC and ARGV are the count and an array of the values of the command line arguments. ARGI is the index value for the next command line argument to be processed. ARGV[0] is the full path/name of QTAwk.exe, and the rest are all the command line arguments except any "-F", "-f" or "--" options. The field separator may set to a single character or a string. If a string, it is interpreted as a regular expression and converted to internal form at the time of assignment. A single space has a special meaning and is changed to /{_z}+/. A BEGIN action may be used to set the separator or it may be set by using the -F command line option or as a command line variable. BEGIN { FS = ",";} sets FS to a single comma "-F/[ ]/" sets FS to a single space "FS=/[ ]/" sets FS to a single space The record separator, RS, may be a single character or string. If a string, then it interpreted as a regular expression and converted to internal form at the time of assignment. Any string matching the regular expression, becomes a record separator. The null string, RS = "", will set RS == /\n\n/, i.e., consecutive newlines delimit records. There are a number of built in functions: Function Value returned acos(x) arc-cosine of x asin(x) arc-sine of x atan2(x,y) arctangent of x/y in the range -π to π center(s,w) string s centered center("abc",75) center(s,w,c) string s centered center("abc",75,'-') copies(s,n) n copies of s copies('=',45) cos(x) cosine of x x in radians/degrees cosh(x) hyperbolic cosine of x deletec(s,p,n) deletec n characters at p deletec("abcdef",2,2) e_type(exp) expression type in range 0 to 5 execute(s) value of expression in s execute string execute(s,se) value of expression in s execute string execute(s,se,rf) value of expression in s execute string execute(a) value of expression in s execute array execute(a,se) value of expression in s execute array execute(a,se,rf) value of expression in s execute array exp(x) exponentiation of x (e ^ x) fract(x) fractional portion of x gsub(r,s) number of substitutions substitute s for all r in $0 gsub(r,s,t) number of substitutions substitute s for all r in t index(s,t) position of t in s 0 if not in s insert(s1,s2,p) string s1 with s2 inserted insert("ad","bc",2) int(x) integer portion of x justify(a,n,w) elements array a as string justified to width w justify(a,n,w,c) elements array a as string justified to width w length number of characters in $0 length(s) number of characters in s log(x) natural logrithm of x log10(x) logrithm base 10 of x match(s,r) position of r in s or 0 sets RSTART and RLENGTH overlay(s1,s2.p) string s1 with s2 overlayed overlay("abc","def",4) pd_sym(name) pre-defined symbol with name equal to string name pd_sym(name) pre-defined symbol with position in symbol table == n pi π 3.14159... pi() π 3.14159... rand() random number 0 <= rand < 1 remove(s,c) string s with c's removed remove("===s===",'=') replace(s) string s with sub-expressions replaced rotate(a) rotated array a sdate(f) current system date formated as string sin(x) sine of x x in radians/degrees sinh(x) hyperbolic sine of x split(s,a) number of fields split s into a on FS split(s,a,fs) number of fields split s into a on fs sprintf(f,e,...) formatted string srange(c1,c2) string from c1 to c3 inclusive srev(s) string s with characters reversed sqrt(x) square root of x srand(seed) random number generator seed stime(f) current system time formatted as string stran(s) string s with characters translated stran(s,st) string s with characters translated stran(s,st,sf) string s with characters translated strim(s) string s with leading & trailing white space removed strim(s,le) string s with leading expression and trailing white space removed strim(s,le,te) string s with leading & trailing expression removed strlwr(s) s tranlated to lower case strupr(s) s tranlated to upper case sub(r,s) number of substitutions substitute s for one r in $0 sub(r,s,t) number of substitutions substitute s for one r in t substr(s,p) substring of s from p to end substr(s,p,n) substring of s from p of length n system(s) exit status execute command s ud_sym(name) user-defined symbol with name equal to string name ud_sym(name) user-defined symbol with position in symbol table == n The numeric function srand(x) sets a new seed for the random number generator. srand() sets the seed from the current system time. The regular expression arguments of sub, gsub, match and strim may be either regular expressions delimited by slashes or any expression. If not a regular expression, the expression is coerced to a string and the resulting string is converted into a regular expression. This coersion and conversion occurs every time the procedure is called so the regular expression form will always be faster. The print, printf and fprintf statements come in several forms: Form Meaning print; print $0 on standard output print expression, ...; prints expressions separated by OFS print(expression, ...); prints expressions separated by OFS printf format, expression, ...; prints expressions formated by "format" printf(format, expression, ...);prints expressions formated by "format" fprint file; print $0 to "file" fprint(file); print $0 to "file" fprint file,expression, ...; prints expressions separated by OFS to "file" fprint(file,expression, ...); prints expressions separated by OFS to "file" fprintf file,format,expression, ...; prints expressions formated by "format" to "file" fprintf(file,format,expression, ..); prints expressions formated by "format" to "file" close(file) close "file" The [f]print statement prints its arguments on the standard output, or the specified file, separated by the current output field separator, and terminated by the output record separator. The [f]printf statement formats its expression-list according to the format. The file is only opened once unless it is closed between executions of the fprint[f] statement. A file that is open for output must be closed if it is to be used for input. The "file" argument may be any expression that evaluates to a DOS file name. There are two functions used for input: Form Meaning getline read the next record into $0 getline s read the next record into s getline(s) read the next record into s fgetline(file) read a record from "file" into $0 fgetline(file,s) read a record from "file" into s getc() read a single character from current input file fgetc(file) read a single character from "file" [f]getline returns -1 if there is an error (such as non existent file), 0 on end of file and the number of characters read otherwise. The current input line and fields and variables NF, NR and FNR are set by the forms of [f]getline according to the following table: │ getline(); │ getline; getline(v); fgetline(F); fgetline(F,v); ───────┼─────────────────────────────────────────────────────── $0 │ set not set set not set $i │ set not set set not set NF │ set not set set not set NR │ set set not set not set FNR │ set set not set not set [f]getc returns the character read or -1 on a read error. 0 is returned if the end of file is reached. If the current input file, for 'getc', or "file", for 'fgetc', is the standard input file and has not been redirected away from the keyboard, either function will return zero, 0, for keystrikes which cannot be represented by an ASCII character. A second call must be made to obtain the extended ASCII character. If the second call also returns zero, then an end of file has been reached. The "for ( i in a )" statement assigns to i the indices of a for all elements in a. The sequencing of the values of i start with any integer values, low to high, then any string values following the ASCII collating sequence (the same sequence as used by the C strcmp functions. The "while ()", "do ... while ()", "for (;;)", break and continue statements are as in C. the switch/case statements are as in C, except that that case labels may be any valid QTAwk expression list. The following logic is followed in matching case labels to the switch expression value: if ( case_label_value == regular expression ) switch_value ~~ case_label_value else switch_value == case_label_value The next statement stops processing the pattern/action statements, reads in the next record and restarts the patterns/actions with the first. The cycle statement will check the current value of CYCLE_COUNT against the value of MAX_CYCLE and perform the following actions: (CYCLE_COUNT is initialized to 1 every time a new record in read from the current input file) 1. CYCLE_COUNT > MAX_CYCLE --> perform same action as "next" statement. 2. CYCLE_COUNT <= MAX_CYCLE --> increment CYCLE_COUNT and restart pattern/action processing with current values of NF, NR, FNR, $0 and $i, 1 <= i <= NF An exit statement will cause the END actions to be performed or if encountered in an END action will cause termination of the program. The optional expression is returned as the exit status unless overridden by a further exit statement in an END action. An endfile statement simulates an end-of-file on the current input file. Any remaining pattern/action pairs are skipped and any FINAL actions are executed before proceesing the next command line argument. The return statement may be used only in function declarations. It may have an optional value which is returned as the value of the function. The value of a function defaults to zero/null string (0/""). REGULAR EXPRESSIONS ^ matches Beginning of Line as first character of expression $ matches End of Line as last character of expression \c matches following (hexadecimal value shown in parenthesis): \a == bell (alert) ( \x07 ) \b == backspace ( \x08 ) \f == formfeed ( \x0c ) \n == newline ( \x0a ) \r == carriage return ( \x0d ) \s == space ( \x20 ) \t == horizontal tab ( \x09 ) \v == vertical tab ( \x0b ) \c == c [ \\ == \ ] \ooo == character represented by octal value ooo 1 to 3 octal digits acceptable \xhh == character represented by hexadecimal value hh 1 or 2 hexadecimal digits acceptable . matches any character [abc0-9] Character Class - match any character in class [^abc0-9] Negated Character Class - match any character not in class [!abc0-9] Negated Character Class - match any character not in class [#abc0-9] Matched Character Class - for second match, class character must match in corresponding position * - Closure, Zero or more matches + - Positive Closure, One or More matches ? - Zero or One matches r(s)t embedded regular expression s r|s|t '|' == logical 'or' operator. Expression r or s or t @ - Look-Ahead, r@t, matches regular expression 'r' only when r is followed by regular expression 't'. Regular expression t not contained in final match. Symbol loses special meaning when contained within parenthesis, '()', or character class, '[]'. r{n1,n2} - at least n1 and up to n2 repetitions of expression r n1, n2 integers with 1 <= n1 <= n2 r{2,6} ==> rrr?r?r?r? r{3,3} ==> rrr Expressions grouped by ", (), [], or names, "{name}" repeated as a group: (Note the treatment of quoted expressions) (r){2,6} ==> (r)(r)(r)?(r)?(r)?(r)? [r]{2,6} ==> [r][r][r]?[r]?[r]?[r]? {r}{2,6} ==> {r}{r}{r}?{r}?{r}?{r}? "r"{2,6} ==> "rr(r)?(r)?(r)?(r)?" {named_expr} - named expression. In regular expressions "{name}" is replaced by the value of the corresponding variable. Unrecognized variable names are not replaced. Names starting with an underscore and followed by a single upper or lower case letter are reserved as predefined. The following predefined names are currently available: {_a} == [A-Za-z] Alphabetic {_b} == [{}()[]<>] Brackets {_c} == [\x001-\x01f\x-7f] Control character {_d} == [0-9] Digit {_e} == [DdEe][-+]?{_d}{1,3} Exponent {_f} == [-+]?({_d}+\.{_d}*|{_d}*\.{_d}+) Floating point number {_g} == {_f}({_e})? float, optional exponent {_h} == [0-9A-Fa-f] Hex-digit {_i} == [-+]?{_d}+ Integer {_n} == [A-Za-z0-9] alpha-Numeric {_o} == [0-7] Octal digit {_p} == [\!-/:-@[-`{-\x07f] Punctuation {_q} == {_s}[\"'] double or single Quote {_r} == {_f}{_e} Real number {_s} == (^|[!\\](\\\\)*) zero or even number of Slashes {_t} == [\s-~] printable character {_u} == [\!-~] graphical character {_w} == [\s\t] White space {_z} == [\t-\r\s] space, \t, \n, \v, \f, \r, \s PRINTF FORMAT QTAwk follows the ANSI standard for the C Language for the format string in the printf and fprintf functions except for the 'P' and 'n' types, which are not supported and will give unpredictable results. A format specification has the form: %[flags][width][.precision][h | l | L]type which is matched by the following regular expression: /%{flags}?{width}?{precision}?[hlL]?{type}/ with: flags = /[-+\s#0]/; width = /({_d}+|\*)/; precision = /(\.({_d}+|\*))/; type = /[diouxXfeEgGcs]/; Each field of the format specification is a single character or a number signifying a particular format option. The type character, which appears after the last optional format field, enclosed in braces '[..]', determines whether the associated argument is interpreted as a character, a string, or a number. The simplest format specification contains only the percent sign and a type character (for example, %s). The optional fields control other aspects of the formatting, as follows: flags ==> Control justification of output and printing of signs, blanks, decimal points, octal and hexadecimal prefixes. width ==> Control minimum number of characters output. precision ==> Controls maximum number of characters printed for all or part of the output field, or minimum number of digits printed for integer values. h, l, L ==> Prefixes that determine size of argument expected (this field is retained only for compatibility to C format strings). h ==> Used as a prefix with the integer types d, i, o, x, and X to specify that the argument is short int, or with u to specify a short unsigned int l == > Used as a prefix with d, i, o, x, and X types to specify that the argument is long int, or with u to specify a long unsigned int; also used as a prefix with e, E, f, g, and G types to specify a double, rather than a float L ==> Used as a prefix with e, E, f, g, and G types to specify a long double If a percent sign, '%', is followed by a character that has no meaning as a format field, the character is simply copied to the output. For example, to print a percent-sign character, use "%%". Type characters: d ==> integer, Signed decimal integer i ==> integer, Signed decimal integer u ==> integer, Unsigned decimal integer o ==> integer, Unsigned octal integer x ==> integer, Unsigned hexadecimal integer, using "abcdef" X ==> integer, Unsigned hexadecimal integer, using "ABCDEF" f ==> float, Signed value having the form [-]dddd.dddd, where dddd is one or more decimal digits. The number of digits before the decimal point depends on the magnitude of the number, and the number of digits after the decimal point depends on the requested precision. e ==> float, Signed value having the form [-]d.dddd e [sign]ddd, where d is a single decimal digit, dddd is one or more decimal digits, ddd is exactly three decimal digits, and sign is + or -. E ==> float, Identical to the e format, except that E introduces the exponent instead of e. g ==> float, Signed value printed in f or e format, whichever is more compact for the given value and precision. The e format is used only when the exponent of the value is less than -4 or greater than the precision argument. Trailing zeros are truncated and the decimal point appears only if one or more digits follow it. G ==> float, Identical to the g format, except that G introduces the exponent (where appropriate) instead of e. c ==> character, Single character s ==> string, Characters printed up to the first null character ('\0') or until the precision value is reached. Flag Characters - ==> Left justify the result within the given field width. Default: Right justify. + ==> Prefix the output value with a sign (+ or -) if the output value is of a signed type. Default: Sign appears only for negative signed values (-). blank (' ') ==> Prefix the output value with a blank if the output value is signed and positive. The blank is ignored if both the blank and + flags appear. Default: No blank. # ==> When used with the o, x, or X format, the # flag prefixes any nonzero output value with 0, 0x, or 0X, respectively. Default: No blank. # ==> When used with the e, E, or f format, the # flag forces the output value to contain a decimal point in all cases. Default: Decimal point appears only if digits follow it. # ==> When used with the g or G format, the # flag forces the output value to contain a decimal point in all cases and prevents the truncation of trailing zeros. Default: Decimal point appears only if digits follow it. Trailing zeros are truncated. # ==> Ignored when used with c, d, i, u or s 0 ==> For d, i, o, u, x, X, e, E, f, g, and G conversions, leading zeros (following any indication of sign or base) are used to pad to the field width; no space padding is performed. If the 0 and - flags both appear, the 0 flag will be ignored. For d, i, o, u, x, and X conversions, if a precision is specified, the 0 flag will be ignored. For other conversions the behavior is undefined. Default: Use blank padding If the argument corresponding to a floating-point specifier is infinite or indefinite, the following output is produced: + infinity ==> 1.#INFrandom-digits - infinity ==> -1.#INFrandom-digits Indefinite ==> digit.#INDrandom-digits The width argument is a non-negative decimal integer controlling the minimum number of characters printed. If the number of characters in the output value is less than the specified width, blanks are added to the left or the right of the values (depending on whether the - flag is specified) until the minimum width is reached. If width is prefixed with a 0 flag, zeros are added until the minimum width is reached (not useful for left-justified numbers). The width specification never causes a value to be truncated; if the number of characters in the output value is greater than the specified width, or width is not given, all characters of the value are printed (subject to the precision specification). The width specification may be an asterisk (*), in which case an integer argument from the argument list supplies the value. The width argument must precede the value being formatted in the argument list. A nonexistent or small field width does not cause a truncation of a field; if the result of a conversion is wider than the field width, the field expands to contain the conversion result. The precision specification is a non-negative decimal integer preceded by a period, '.', which specifies the number of characters to be printed, the number of decimal places, or the number of significant digits. Unlike the width specification, the precision can cause truncation of the output value, or rounding in the case of a floating-point value. The precision specification may be an asterisk, '*', in which case an integer argument from the argument list supplies the value. The precision argument must precede the value being formatted in the argument list. The interpretation of the precision value, and the default when precision is omitted, depend on the type, as shown below: d,i,u,o,x,X ==> The precision specifies the minimum number of digits to be printed. If the number of digits in the argument is less than precision, the output value is padded on the left with zeros. The value is not truncated when the number of digits exceeds precision. Default: If precision is 0 or omitted entirely, or if the period (.) appears without a number following it, the precision is set to 1. e, E ==> The precision specifies the number of digits to be printed after the decimal point. The last printed digit is rounded. Default: Default precision is 6; if precision is 0 or the period (.) appears without a number following it, no decimal point is printed. f ==> The precision value specifies the number of digits after the decimal point. If a decimal point appears, at least one digit appears before it. The value is rounded to the appropriate number of digits. Default: Default precision is 6; if precision is 0, or if the period (.) appears without a number following it, no decimal point appears. g, G ==> The precision specifies the maximum number of significant digits printed. Default: Six significant digits are printed, without any trailing zeros that are truncated. c ==>No effect. Default: Character printed s ==> The precision specifies the maximum number of characters to be printed. Characters in excess of precision are not printed. Default: All characters of the string are printed. EXAMPLES Print lines longer than 72 characters (missing action is print): length($0) > 72 or length > 72 Print first two fields in opposite order (missing pattern is always match): { print $2, $1; } Add up first column, print sum and average: { s += $1; } END { print "sum is", s, "average is", s/NR } Print fields in reverse order: { for ( i = NF ; i > 0 ; --i ) print $i; } Print all lines between start/stop pairs: /start/,/stop/ Print all lines whose first field is different from previous one: $1 != prev { print; prev = $1; } Convert date from MM/DD/YY to metric (YYMMDD): { n = split(sdate(0),a,"/"); date = a[3] ∩ a[1] ∩ a[2] } Copy a C program and insert include files: $1 == "#include" && $2 ~~ /^"/ { local tfile = $2; gsub(/"/, "",tfile); while ( fgetline(tfile,tmp) > 0 ) print tmp; next; } { print; } AUTHOR QTAwk Utility Creation Program Version 4.01 07-04-90 (c) Copyright 1988 - 1990 Pearl Boldt. All Rights Reserved. All warranties as to this software, whether express or implied, are disclaimed, including without limitation any implied warranties of merchantability, fitness for a particular purpose, functionality or data integrity or protection are disclaimed. You are free to use, copy and give to others QTawk for noncommercial use IF: => NO FEE IS CHARGED FOR USE, COPYING OR DISTRIBUTION. => ALL FILES AND DOCUMENTATION ACCOMPANY THE PROGRAMS. => THEY ARE NOT MODIFIED IN ANY WAY. If you find QTAwk convenient to use, a registration of $35 would be appreciated. If you send $50 or more you will receive, when available, the current and next version of the QTgrep, QSgrep and flagset programs and documentation. Pearl Boldt 13012 Birdale Lane Darnestown, MD 20878 If you find QTAwk convenient to use, a registration of $35 would be appreciated. If you send $50 or more you will receive the current and, when available, next version of the QTAwk program and documentation. Questions may be sent to the address above or to CompuServe ID: 72040.434 Site licenses are available for QTAwk. Inquires should be addressed to the copyright holder listed above or the CompuServe ID listed. All inquires concerning the use and/or distribution of QTAwk, documentation and accompanying files should be addressed to the copyright holder listed above or the CompuServe ID listed. SEE ALSO: A. V Aho, B. W Kernighan, P. J. Weinberger, "The AWK Programming Language" Addison-Wesley 1988 ISBN 0-201-07981-X